﻿using System;
using System.Data;
using DTO.Clases;
using Npgsql;

namespace DataAccessLayer.Clases
{
    /// <summary>
    /// Representa una clase para la pertinencia de datos de Factura de venta.
    /// </summary>
    public class DaoFacturaVenta
    {
        #region Transacción a base de datos.

        /// <summary>
        /// Representa un objeto con acceso a la conexión de base de datos Postgresql.
        /// </summary>
        private Conexion miConexion;

        /// <summary>
        /// Representa un comando de ejecucion de sentencias SQL a PostgreSQL.
        /// </summary>
        private NpgsqlCommand miComando;

        /// <summary>
        /// Objeto adaptador de consultas SQL a servidor PostgreSQL.
        /// </summary>
        private NpgsqlDataAdapter miAdapter;

        #endregion

        #region Funciones

        /// <summary>
        /// Representa la función recuperar_consecutivo.
        /// </summary>
        private string ObtenerConsicutivo = "recuperar_consecutivo";

        /// <summary>
        /// Representa la función obtener_rango_final.
        /// </summary>
        private string RangoFinal = "obtener_rango_final";

        /// <summary>
        /// Representa la función: obtener_rango_final_credito.
        /// </summary>
        private string RangoFinalCredito = "obtener_rango_final_credito";

        /// <summary>
        /// Representa la función insertar_factura_venta.
        /// </summary>
        private string Ingresar = "insertar_factura_venta";

        /// <summary>
        /// Representa la Función: print_factura_venta.
        /// </summary>
        private string PrintFacturaVenta_ = "print_factura_venta";

        /// <summary>
        /// Representa la función editar_factura_venta.
        /// </summary>
        private string Editar = "editar_factura_venta";

        /// <summary>
        /// Representa la función actualizar_consecutivo.
        /// </summary>
        private string ActualizarConsecutivo_ = "actualizar_consecutivo";

        /// <summary>
        /// Representa la función: consulta_factura_venta_numero.
        /// </summary>
        private string ConsultaNumero_ = "consulta_factura_venta_numero";

        /// <summary>
        /// Representa la función: consulta_factura_venta_estado.
        /// </summary>
        private string ConsultaEstado_ = "consulta_factura_venta_estado";

        /// <summary>
        /// Representa la función: consulta_factura_venta_estado_ingreso.
        /// </summary>
        private string ConsultaEstadoFechaIngreso_ = "consulta_factura_venta_estado_ingreso";

        /// <summary>
        /// Representa la función: consulta_factura_venta_estado_periodo.
        /// </summary>
        private string ConsultaEstadoPeriodoIngreso_ = "consulta_factura_venta_estado_periodo";

        /// <summary>
        /// Representa la función: consulta_factura_todas_cliente.
        /// </summary>
        private string ConsultaPorCliente_ = "consulta_factura_todas_cliente";

        /// <summary>
        /// Representa la función: consulta_factura_estado_y_cliente.
        /// </summary>
        private string ConsultaPorEstadoYcliente_ = "consulta_factura_estado_y_cliente";

        /// <summary>
        /// Representa la función: consulta_factura_todas_cliente_fingreso.
        /// </summary>
        private string ConsultaPorClienteIngreso_ = "consulta_factura_todas_cliente_fingreso";

        /// <summary>
        /// Representa la función: consulta_factura_estado_cliente_fingreso.
        /// </summary>
        private string ConsultaPorEstadoClienteIngreso_ = "consulta_factura_estado_cliente_fingreso";

        /// <summary>
        /// Representa la función: consulta_factura_todas_cliente_periodo.
        /// </summary>
        private string ConsultaPorClientePeriodoIngreso_ = "consulta_factura_todas_cliente_periodo";

        /// <summary>
        /// Representa la función: consulta_factura_estado_cliente_periodo.
        /// </summary>
        private string ConsultaPorEstadoClientePeriodoIngreso_ = "consulta_factura_estado_cliente_periodo";

        /// <summary>
        /// Representa la función: consulta_factura_mora.
        /// </summary>
        private string ConsultaEnMora_ = "consulta_factura_mora";

        /// <summary>
        /// Representa la función: consulta_factura_cliente_mora.
        /// </summary>
        private string ConsultaClienteEnMora_ = "consulta_factura_cliente_mora";

        /// <summary>
        /// Representa la función: consulta_factura_estado_flimite.
        /// </summary>
        private string ConsultaEstadoFechaLimite_ = "consulta_factura_estado_flimite";

        /// <summary>
        /// Representa la función: consulta_factura_estado_periodo.
        /// </summary>
        private string ConsultaCreditoPeriodo_ = "consulta_factura_estado_periodo";

        /// <summary>
        /// Representa la función: consulta_factura_cliente_estado_flimite.
        /// </summary>
        private string ConsultaClienteCreditoLimite_ = "consulta_factura_cliente_estado_flimite";

        /// <summary>
        /// Representa la función: consulta_factura_cliente_estado_periodo.
        /// </summary>
        private string ConsultaClienteCreditoLimitePeriodo_ = "consulta_factura_cliente_estado_periodo";

        /// <summary>
        /// Representa la función: count_consulta_factura_venta_estado.
        /// </summary>
        private string GetRowsConsultaEstado_ = "count_consulta_factura_venta_estado";

        /// <summary>
        /// Representa la función: count_consulta_factura_venta_estado_ingreso.
        /// </summary>
        private string GetRowsConsultaEstadoFechaIngreso_ = "count_consulta_factura_venta_estado_ingreso";

        /// <summary>
        /// Representa la función: count_consulta_factura_venta_estado_periodo.
        /// </summary>
        private string GetRowsConsultaEstadoPeriodoIngreso_ = "count_consulta_factura_venta_estado_periodo";

        /// <summary>
        /// Representa la función: count_consulta_factura_todas_cliente.
        /// </summary>
        private string GetRowsConsultaPorCliente_ = "count_consulta_factura_todas_cliente";

        /// <summary>
        /// Representa la función: count_consulta_factura_estado_y_cliente.
        /// </summary>
        private string GetRowsConsultaPorEstadoYcliente_ = "count_consulta_factura_estado_y_cliente";

        /// <summary>
        /// Representa la función: count_consulta_factura_todas_cliente_fingreso.
        /// </summary>
        private string GetRowsConsultaPorClienteIngreso_ = "count_consulta_factura_todas_cliente_fingreso";

        /// <summary>
        /// Representa la función: count_consulta_factura_todas_cliente_periodo.
        /// </summary>
        private string GetRowsConsultaPorClientePeriodoIngreso_ = "count_consulta_factura_todas_cliente_periodo";

        /// <summary>
        /// Representa la función: count_consulta_factura_estado_cliente_periodo.
        /// </summary>
        private string GetRowsEstadoClientePeriodoIngreso_ = "count_consulta_factura_estado_cliente_periodo";

        /// <summary>
        /// Representa la función: count_consulta_factura_mora.
        /// </summary>
        private string GetRowsConsultaEnMora_ = "count_consulta_factura_mora";

        /// <summary>
        /// Representa la función: count_consulta_factura_cliente_mora.
        /// </summary>
        private string GetRowsConsultaClienteEnMora_ = "count_consulta_factura_cliente_mora";

        /// <summary>
        /// Representa la función: count_consulta_factura_estado_flimite.
        /// </summary>
        private string GetRowsConsultaEstadoFechaLimite_ = "count_consulta_factura_estado_flimite";

        /// <summary>
        /// Representa la función: count_consulta_factura_estado_periodo.
        /// </summary>
        private string GetRowsConsultaCreditoPeriodo_ = "count_consulta_factura_estado_periodo";

        /// <summary>
        /// Representa la función: count_consulta_factura_cliente_estado_flimite.
        /// </summary>
        private string GetRowsConsultaClienteCreditoLimite_ = "count_consulta_factura_cliente_estado_flimite";

        /// <summary>
        /// Representa la función: count_consulta_factura_cliente_estado_periodo.
        /// </summary>
        private string GetRowsConsultaClienteCreditoLimitePeriodo_ =
            "count_consulta_factura_cliente_estado_periodo";









        #endregion

        #region Mensajes

        /// <summary>
        /// Representa el texto: Ocurrió un error al obtener el rango de números.
        /// </summary>
        private string ErrorRango = "Ocurrió un error al obtener el rango de números.\n";

        /// <summary>
        /// Representa el texto: Ocurrió un error al obtener el rango de números.
        /// </summary>
        private string ErrorNumero = "Ocurrió un error al obtener el número consecutivo.\n";

        /// <summary>
        /// Representa el texto: Ocurrió un error al ingresar la factura de venta.
        /// </summary>
        private string ErrorIngresar = "Ocurrió un error al ingresar la factura de venta.\n";

        /// <summary>
        /// Representa el texto: Ocurrió un error al editar la factura de venta.
        /// </summary>
        private string ErrorEditar = "Ocurrió un error al editar la factura de venta.\n";

        /// <summary>
        /// Representa el texto: Ocurrió un error al actualizar el consecutivo de la factura.
        /// </summary>
        private string ErrorActualizaConsecutivo = "Ocurrió un error al actualizar el consecutivo de la factura.\n";

        /// <summary>
        /// Representa el texto: Ocurrió un error al consultar la Factura de Venta.
        /// </summary>
        private string ErrorConsulta = "Ocurrió un error al consultar la Factura de Venta.\n";

        /// <summary>
        /// Representa el texto: Ocurrió un error al obtener el número de registros.
        /// </summary>
        private string ErrorGetRows = "Ocurrió un error al obtener el número de registros.\n";

        #endregion

        /// <summary>
        /// Inicializa una nueva instancia de la clase DaoFacuraVenta.
        /// </summary>
        public DaoFacturaVenta()
        {
            this.miConexion = new Conexion();
        }

        /// <summary>
        /// Obtiene el Número consecutivo a se asignado en la Factura.
        /// </summary>
        /// <returns></returns>
        public string ObtenerNumero(bool contado)
        {
            try
            {
                CargarComando(ObtenerConsicutivo);
                if (contado)
                {
                    miComando.Parameters.AddWithValue("nombre", "Factura");
                }
                else
                {
                    miComando.Parameters.AddWithValue("nombre", "FacturaCredito");
                }
                miConexion.MiConexion.Open();
                var numero = Convert.ToString(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return numero;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorNumero + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el número correspondiente al rango final del registro de la Dian.
        /// </summary>
        /// <returns></returns>
        public long ObtenerRangoFinal(bool contado)
        {
            try
            {
                if (contado)
                {
                    CargarComando(RangoFinal);
                }
                else
                {
                    CargarComando(RangoFinalCredito);
                }
                miConexion.MiConexion.Open();
                var numero = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return numero;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorRango + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Ingresa el registro de una Factura a base de datos.
        /// </summary>
        /// <param name="factura">Factura a ingresar.</param>
        /// <param name="edicion">Indica si la factura proviene de una edición de la misma.</param>
        public void IngresarFactura(FacturaVenta factura, bool edicion)
        {
            var miDaoProductoFactura = new DaoProductoFacturaVenta();
            var miDaoInventario = new DaoInventario();
            var miDaoPago = new DaoFormaPago();
            try
            {
                if (edicion)
                {
                    CargarComando(Editar);
                }
                else
                {
                    CargarComando(Ingresar);
                }
                //miComando.Parameters.AddWithValue("numero", factura.Numero);
                if (edicion)
                {
                    miComando.Parameters.AddWithValue("numeroEdit", factura.NumeroEdit);
                    miComando.Parameters.AddWithValue("numero", factura.Numero);
                }
                else
                {
                    miComando.Parameters.AddWithValue("numero", factura.Numero);
                }
                miComando.Parameters.AddWithValue("cliente", factura.Proveedor.NitProveedor);
                miComando.Parameters.AddWithValue("usuario", factura.Usuario.Id);
                miComando.Parameters.AddWithValue("caja", factura.Caja.Id);
                miComando.Parameters.AddWithValue("estado", factura.EstadoFactura.Id);
                miComando.Parameters.AddWithValue("fecha", factura.FechaIngreso);
                miComando.Parameters.AddWithValue("hora", factura.FechaIngreso.TimeOfDay);
                miComando.Parameters.AddWithValue("descuento", factura.Descuento);
                miComando.Parameters.AddWithValue("limite", factura.FechaLimite);
                miComando.Parameters.AddWithValue("aplicaDescto", factura.AplicaDescuento);
                miConexion.MiConexion.Open();
                miComando.ExecuteNonQuery();
                miConexion.MiConexion.Close();
                miComando.Dispose();
                foreach (ProductoFacturaProveedor producto in factura.Productos)
                {
                    if (edicion)
                    {
                        if (producto.Save)//indica que el registro es nuevo
                        {
                            miDaoProductoFactura.IngresarProductoFactura(producto);
                            miDaoInventario.ActualizarInventario(producto.Inventario, true);
                        }
                        else
                        {
                            miDaoProductoFactura.EditarProductoFactura(producto);
                        }
                    }
                    else
                    {
                        miDaoProductoFactura.IngresarProductoFactura(producto);
                        miDaoInventario.ActualizarInventario(producto.Inventario, true);
                    }
                }
                ///validar que consecutivo actualizo si contado o credito.
                if (factura.EstadoFactura.Id == 2)  //credito
                {
                    ActualizarConsecutivo(NumberIncrement(factura.Numero), false);
                    //ActualizarConsecutivo(NumberIncrement(factura.Numero), true);
                }
                else         //contado
                {
                    if (factura.EstadoFactura.Id == 1/* && !edicion*/)
                    {
                        ActualizarConsecutivo(NumberIncrement(factura.Numero), true);
                    }
                }
                foreach (FormaPago forma in factura.FormasDePago)
                {
                    if (forma.Valor != 0)
                    {
                        forma.Fecha = factura.FechaIngreso;
                        forma.NumeroFactura = factura.Numero;
                        forma.Usuario.Id = factura.Usuario.Id;
                        forma.Caja.Id = factura.Caja.Id;
                        miDaoPago.IngresarPagoAFactura(forma, true);
                    }
                }
            }
            catch (Exception ex)
            {
                if (edicion)
                {
                    throw new Exception(ErrorEditar + ex.Message);
                }
                else
                {
                    throw new Exception(ErrorIngresar + ex.Message);
                }
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Incrementa en una unidad un número determinado.
        /// </summary>
        /// <param name="numero">Número a incrementar.</param>
        /// <returns></returns>
        private string NumberIncrement(string numero)
        {
            long num = 0;
            try
            {
                num = Convert.ToInt64(numero);
                num++;
                numero = Utilities.UseObject.CerosToLeft(numero) + num.ToString();
            }
            catch
            {
                var n = numero.Split('-');
                num = Convert.ToInt64(n[1]);
                num++;
                numero = n[0] + '-' + Utilities.UseObject.CerosToLeft(numero) +
                         num.ToString();
                n = null;
            }
            return numero;
        }

        /// <summary>
        /// Actualiza el registro del consecutivo de Factura de Venta.
        /// </summary>
        /// <param name="numero">Número a ingresar en la actualización del registro.</param>
        /// <param name="contado">Indica si se trata de un registro de Factura de contado o no.</param>
        public void ActualizarConsecutivo(string numero, bool contado)
        {
            try
            {
                CargarComando(ActualizarConsecutivo_);
                if (contado)
                {
                    miComando.Parameters.AddWithValue("concepto", "Factura");
                }
                else
                {
                    miComando.Parameters.AddWithValue("concepto", "FacturaCredito");
                }
                miComando.Parameters.AddWithValue("numero", numero);
                miConexion.MiConexion.Open();
                miComando.ExecuteNonQuery();
                miConexion.MiConexion.Close();
                miComando.Dispose();
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorActualizaConsecutivo + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene los datos de la factura de venta para su impresión.
        /// </summary>
        /// <param name="numero">Número de la factura de venta.</param>
        /// <returns></returns>
        public DataSet PrintFacturaVenta(string numero)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(PrintFacturaVenta_);
                miAdapter.SelectCommand.Parameters.AddWithValue("numero", numero);
                miAdapter.Fill(dataSet, "FacturaVenta");
                return dataSet;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por número.
        /// </summary>
        /// <param name="numero">Número de la Factura a consultar.</param>
        /// <returns></returns>
        public DataTable ConsultaNumero(string numero)
        {
            var tabla = new DataTable();
            try
            {
                CargarAdapter(ConsultaNumero_);
                miAdapter.SelectCommand.Parameters.AddWithValue("numero", numero);
                miAdapter.Fill(tabla);
                return tabla;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por Estado de la Factura.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaEstado(int estado, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaEstado_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de resultado de la consulta de Factura de Venta 
        /// por Estado de la Factura.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <returns></returns>
        public long GetRowsConsultaEstado(int estado)
        {
            try
            {
                CargarComando(GetRowsConsultaEstado_);
                miComando.Parameters.AddWithValue("estado", estado);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por Estado de la Factura 
        /// y fecha de ingreso de la misma.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="fecha">Fecha de ingreso a consultar la factura.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaEstadoFechaIngreso
            (int estado, DateTime fecha, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaEstadoFechaIngreso_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha", fecha);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de Factura de Venta por Estado de la Factura 
        /// y fecha de ingreso de la misma.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="fecha">Fecha de ingreso a consultar la factura.</param>
        /// <returns></returns>
        public long GetRowsConsultaEstadoFechaIngreso(int estado, DateTime fecha)
        {
            try
            {
                CargarComando(GetRowsConsultaEstadoFechaIngreso_);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("fecha", fecha);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por Estado de la Factura 
        /// y un periodo de fechas para la consulta en la fecha de ingreso.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaEstadoPeriodoIngreso
            (int estado, DateTime fecha1, DateTime fecha2, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaEstadoPeriodoIngreso_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha1", fecha1);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha2", fecha2);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de Factura de Venta por Estado de la Factura 
        /// y un periodo de fechas para la consulta en la fecha de ingreso.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <returns></returns>
        public long GetRowsConsultaEstadoPeriodoIngreso
            (int estado, DateTime fecha1, DateTime fecha2)
        {
            try
            {
                CargarComando(GetRowsConsultaEstadoPeriodoIngreso_);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("fecha1", fecha1);
                miComando.Parameters.AddWithValue("fecha2", fecha2);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por Cliente 
        /// relacionado con la misma.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaPorCliente(string cliente, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaPorCliente_);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de de Factura de Venta por Cliente 
        /// relacionado con la misma.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <returns></returns>
        public long GetRowsConsultaPorCliente(string cliente)
        {
            try
            {
                CargarComando(GetRowsConsultaPorCliente_);
                miComando.Parameters.AddWithValue("cliente", cliente);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por estado y Cliente.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaPorEstadoYcliente
            (int estado, string cliente, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaPorEstadoYcliente_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de Factura de Venta por estado y Cliente.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <returns></returns>
        public long GetRowsConsultaPorEstadoYcliente(int estado, string cliente)
        {
            try
            {
                CargarComando(GetRowsConsultaPorEstadoYcliente_);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("cliente", cliente);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por Cliente 
        /// y fecha de ingreso de la misma.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="fecha">Fecha de ingreso a consultar la factura.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaPorClienteIngreso
            (string cliente, DateTime fecha, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaPorClienteIngreso_);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha", fecha);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de Factura de Venta por Cliente 
        /// y fecha de ingreso de la misma.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="fecha">Fecha de ingreso a consultar la factura.</param>
        /// <returns></returns>
        public long GetRowsConsultaPorClienteIngreso(string cliente, DateTime fecha)
        {
            try
            {
                CargarComando(GetRowsConsultaPorClienteIngreso_);
                miComando.Parameters.AddWithValue("cliente", cliente);
                miComando.Parameters.AddWithValue("fecha", fecha);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por Estado, 
        /// Cliente y fecha de ingreso.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="fecha">Fecha de ingreso a consultar la factura.</param>
        /// <returns></returns>
        public DataTable ConsultaPorEstadoClienteIngreso
            (int estado, string cliente, DateTime fecha)
        {
            var dataTable = new DataTable();
            try
            {
                CargarAdapter(ConsultaPorEstadoClienteIngreso_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha", fecha);
                miAdapter.Fill(dataTable);
                return dataTable;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por Cliente 
        /// en un periodo de fechas de ingreso.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaPorClientePeriodoIngreso
            (string cliente, DateTime fecha1, DateTime fecha2, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaPorClientePeriodoIngreso_);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha1", fecha1);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha2", fecha2);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de Factura de Venta por Cliente 
        /// en un periodo de fechas de ingreso.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <returns></returns>
        public long GetRowsConsultaPorClientePeriodoIngreso
            (string cliente, DateTime fecha1, DateTime fecha2)
        {
            try
            {
                CargarComando(GetRowsConsultaPorClientePeriodoIngreso_);
                miComando.Parameters.AddWithValue("cliente", cliente);
                miComando.Parameters.AddWithValue("fecha1", fecha1);
                miComando.Parameters.AddWithValue("fecha2", fecha2);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de Factura de Venta por Estado, 
        /// Cliente y un periodo entre fechas de ingreso.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaPorEstadoClientePeriodoIngreso
            (int estado, string cliente, DateTime fecha1, DateTime fecha2, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter
                    (ConsultaPorEstadoClientePeriodoIngreso_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha1", fecha1);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha2", fecha2);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de Factura de Venta por Estado, 
        /// Cliente y un periodo entre fechas de ingreso.
        /// </summary>
        /// <param name="estado">Estado de la factura a consultar.</param>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <returns></returns>
        public long GetRowsEstadoClientePeriodoIngreso
            (int estado, string cliente, DateTime fecha1, DateTime fecha2)
        {
            try
            {
                CargarComando(GetRowsEstadoClientePeriodoIngreso_);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("cliente", cliente);
                miComando.Parameters.AddWithValue("fecha1", fecha1);
                miComando.Parameters.AddWithValue("fecha2", fecha2);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de las Facturas de Venta 
        /// que se encuentran en mora hasta la fecha actual.
        /// </summary>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha">Fecha actual de la consulta.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaEnMora
            (int estado, DateTime fecha, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaEnMora_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha", fecha);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de Facturas de Venta 
        /// que se encuentran en mora hasta la fecha actual.
        /// </summary>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha">Fecha actual de la consulta.</param>
        /// <returns></returns>
        public long GetRowsConsultaEnMora(int estado, DateTime fecha)
        {
            try
            {
                CargarComando(GetRowsConsultaEnMora_);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("fecha", fecha);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de las Facturas de Venta 
        /// de un Cliente que se encuentran en mora hasta la fecha actual.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha">Fecha actual de la consulta.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaClienteEnMora
            (string cliente, int estado, DateTime fecha, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaClienteEnMora_);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha", fecha);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de las Facturas de Venta 
        /// de un Cliente que se encuentran en mora hasta la fecha actual.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha">Fecha actual de la consulta.</param>
        /// <returns></returns>
        public long GetRowsConsultaClienteEnMora
            (string cliente, int estado, DateTime fecha)
        {
            try
            {
                CargarComando(GetRowsConsultaClienteEnMora_);
                miComando.Parameters.AddWithValue("cliente", cliente);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("fecha", fecha);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de las Facturas de Venta 
        /// con un tope en la fecha límite.
        /// </summary>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha">Fecha límite hasta donde se quiere consultar.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaEstadoFechaLimite
                         (int estado, DateTime fecha, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaEstadoFechaLimite_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha", fecha);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de las Facturas de Venta 
        /// con un tope en la fecha límite.
        /// </summary>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha">Fecha límite hasta donde se quiere consultar.</param>
        /// <returns></returns>
        public long GetRowsConsultaEstadoFechaLimite(int estado, DateTime fecha)
        {
            try
            {
                CargarComando(GetRowsConsultaEstadoFechaLimite_);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("fecha", fecha);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de las Facturas de Venta 
        /// en crédito en un periodo de fechas.
        /// </summary>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaCreditoPeriodo
            (int estado, DateTime fecha1, DateTime fecha2, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaCreditoPeriodo_);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha1", fecha1);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha2", fecha2);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de las Facturas de Venta 
        /// en crédito en un periodo de fechas.
        /// </summary>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <returns></returns>
        public long GetRowsConsultaCreditoPeriodo(int estado, DateTime fecha1, DateTime fecha2)
        {
            try
            {
                CargarComando(GetRowsConsultaCreditoPeriodo_);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("fecha1", fecha1);
                miComando.Parameters.AddWithValue("fecha2", fecha2);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de las Facturas de Venta 
        /// en Crédito de un Cliente.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha">Fecha límite hasta donde se quiere consultar.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaClienteCreditoLimite
            (string cliente, int estado, DateTime fecha, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaClienteCreditoLimite_);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha", fecha);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de las Facturas de Venta 
        /// en Crédito de un Cliente.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha">Fecha límite hasta donde se quiere consultar.</param>
        /// <returns></returns>
        public long GetRowsConsultaClienteCreditoLimite(string cliente, int estado, DateTime fecha)
        {
            try
            {
                CargarComando(GetRowsConsultaClienteCreditoLimite_);
                miComando.Parameters.AddWithValue("cliente", cliente);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("fecha", fecha);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }

        /// <summary>
        /// Obtiene el resultado de la consulta de las Facturas de Venta 
        /// en Crédito de un Cliente en un periodo determinado.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <param name="rowBase">Registro base para la consulta.</param>
        /// <param name="rowMax">Número de registros a recuperar.</param>
        /// <returns></returns>
        public DataTable ConsultaClienteCreditoLimitePeriodo
            (string cliente, int estado, DateTime fecha1, DateTime fecha2, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaClienteCreditoLimitePeriodo_);
                miAdapter.SelectCommand.Parameters.AddWithValue("cliente", cliente);
                miAdapter.SelectCommand.Parameters.AddWithValue("estado", estado);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha1", fecha1);
                miAdapter.SelectCommand.Parameters.AddWithValue("fecha2", fecha2);
                miAdapter.Fill(dataSet, rowBase, rowMax, "factura");
                return dataSet.Tables[0];
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }

        /// <summary>
        /// Obtiene el total de registros de la consulta de las Facturas de Venta 
        /// en Crédito de un Cliente en un periodo determinado.
        /// </summary>
        /// <param name="cliente">Cliente a consultar factura de venta.</param>
        /// <param name="estado">Estado (Crédito) de la factura a consultar.</param>
        /// <param name="fecha1">Primer rango de fecha.</param>
        /// <param name="fecha2">Segundo rango de fecha.</param>
        /// <returns></returns>
        public long GetRowsConsultaClienteCreditoLimitePeriodo
            (string cliente, int estado, DateTime fecha1, DateTime fecha2)
        {
            try
            {
                CargarComando(GetRowsConsultaClienteCreditoLimitePeriodo_);
                miComando.Parameters.AddWithValue("cliente", cliente);
                miComando.Parameters.AddWithValue("estado", estado);
                miComando.Parameters.AddWithValue("fecha1", fecha1);
                miComando.Parameters.AddWithValue("fecha2", fecha2);
                miConexion.MiConexion.Open();
                var rows = Convert.ToInt64(miComando.ExecuteScalar());
                miConexion.MiConexion.Close();
                miComando.Dispose();
                return rows;
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorGetRows + ex.Message);
            }
            finally { miConexion.MiConexion.Close(); }
        }



        /*public DataTable ConsultaEstadoFechaIngreso
            (int estado, DateTime fecha, int rowBase, int rowMax)
        {
            var dataSet = new DataSet();
            try
            {
                CargarAdapter(ConsultaEstadoFechaIngreso_);
            }
            catch (Exception ex)
            {
                throw new Exception(ErrorConsulta + ex.Message);
            }
        }*/





        /// <summary>
        /// Inicializa una nueva instancia de NpgsqlCommand de tipo StoredProcedure.
        /// </summary>
        /// <param name="cmd">Comando a ejecutar.</param>
        private void CargarComando(string cmd)
        {
            miComando = new NpgsqlCommand();
            miComando.Connection = miConexion.MiConexion;
            miComando.CommandType = CommandType.StoredProcedure;
            miComando.CommandText = cmd;
        }

        /// <summary>
        /// Inicializa una nueva instancia de NpgsqlDataAdapter de tipo StoredProcedure.
        /// </summary>
        /// <param name="cmd">Comando a ejecutar.</param>
        private void CargarAdapter(string cmd)
        {
            this.miAdapter = new NpgsqlDataAdapter(cmd, miConexion.MiConexion);
            this.miAdapter.SelectCommand.CommandType = CommandType.StoredProcedure;
        }
    }
}